using System;
using System.Collections.Generic;
using ns26;
using ns27;
using Triton.Game.Mono;

namespace Triton.Game.Mapping
{
	[Attribute38("HistoryManager")]
	public class HistoryManager : MonoBehaviour
	{
		[Attribute38("HistoryManager.BigCardEntry")]
		public class BigCardEntry : MonoClass
		{
			public HistoryInfo m_info => method_3<HistoryInfo>("m_info");

			public bool m_fromMetaData => method_2<bool>("m_fromMetaData");

			public bool m_countered => method_2<bool>("m_countered");

			public bool m_waitForSecretSpell => method_2<bool>("m_waitForSecretSpell");

			public int m_displayTimeMS => method_2<int>("m_displayTimeMS");

			public BigCardEntry(IntPtr address, string className)
				: base(address, className)
			{
			}

			public BigCardEntry(IntPtr address)
				: this(address, "BigCardEntry")
			{
			}
		}

		public enum BigCardTransformState
		{
			INVALID,
			PRE_TRANSFORM,
			TRANSFORM,
			POST_TRANSFORM
		}

		[Attribute38("HistoryManager.TileEntry")]
		public class TileEntry : MonoClass
		{
			public HistoryInfo m_lastAttacker => method_3<HistoryInfo>("m_lastAttacker");

			public HistoryInfo m_lastDefender => method_3<HistoryInfo>("m_lastDefender");

			public HistoryInfo m_lastCardPlayed => method_3<HistoryInfo>("m_lastCardPlayed");

			public HistoryInfo m_lastCardTriggered => method_3<HistoryInfo>("m_lastCardTriggered");

			public HistoryInfo m_lastCardTargeted => method_3<HistoryInfo>("m_lastCardTargeted");

			public List<HistoryInfo> m_affectedCards => method_3<Class271<HistoryInfo>>("m_affectedCards")?.method_25();

			public HistoryInfo m_fatigueInfo => method_3<HistoryInfo>("m_fatigueInfo");

			public bool m_usingMetaDataOverride => method_2<bool>("m_usingMetaDataOverride");

			public bool m_complete => method_2<bool>("m_complete");

			public TileEntry(IntPtr address, string className)
				: base(address, className)
			{
			}

			public TileEntry(IntPtr address)
				: this(address, "TileEntry")
			{
			}

			public void SetAttacker(Entity attacker)
			{
				method_8("SetAttacker", attacker);
			}

			public void SetDefender(Entity defender)
			{
				method_8("SetDefender", defender);
			}

			public void SetCardPlayed(Entity entity)
			{
				method_8("SetCardPlayed", entity);
			}

			public void SetCardTargeted(Entity entity)
			{
				method_8("SetCardTargeted", entity);
			}

			public void SetCardTriggered(Entity entity)
			{
				method_8("SetCardTriggered", entity);
			}

			public void SetFatigue()
			{
				method_8("SetFatigue");
			}

			public bool CanDuplicateAllEntities(bool duplicateHiddenNonSecrets, bool isEndOfHistory)
			{
				return method_11<bool>("CanDuplicateAllEntities", new object[2] { duplicateHiddenNonSecrets, isEndOfHistory });
			}

			public void DuplicateAllEntities(bool duplicateHiddenNonSecrets, bool isEndOfHistory)
			{
				method_8("DuplicateAllEntities", duplicateHiddenNonSecrets, isEndOfHistory);
			}

			public bool ShouldDuplicateEntity(HistoryInfo info)
			{
				return method_11<bool>("ShouldDuplicateEntity", new object[1] { info });
			}

			public HistoryInfo GetSourceInfo()
			{
				return method_14<HistoryInfo>("GetSourceInfo", Array.Empty<object>());
			}

			public HistoryInfo GetTargetInfo()
			{
				return method_14<HistoryInfo>("GetTargetInfo", Array.Empty<object>());
			}
		}

		public Texture m_mageSecretTexture => method_3<Texture>("m_mageSecretTexture");

		public Texture m_paladinSecretTexture => method_3<Texture>("m_paladinSecretTexture");

		public Texture m_hunterSecretTexture => method_3<Texture>("m_hunterSecretTexture");

		public Texture m_wandererSecretTexture => method_3<Texture>("m_wandererSecretTexture");

		public Texture m_FatigueTexture => method_3<Texture>("m_FatigueTexture");

		public SoundDucker m_SoundDucker => method_3<SoundDucker>("m_SoundDucker");

		public Spell m_TransformSpell => method_3<Spell>("m_TransformSpell");

		public static float BIG_CARD_POWER_PROCESSOR_DELAY_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "HistoryManager", "BIG_CARD_POWER_PROCESSOR_DELAY_TIME");

		public static float BIG_CARD_SPELL_DISPLAY_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "HistoryManager", "BIG_CARD_SPELL_DISPLAY_TIME");

		public static float BIG_CARD_MINION_DISPLAY_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "HistoryManager", "BIG_CARD_MINION_DISPLAY_TIME");

		public static float BIG_CARD_HERO_POWER_DISPLAY_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "HistoryManager", "BIG_CARD_HERO_POWER_DISPLAY_TIME");

		public static float BIG_CARD_SECRET_DISPLAY_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "HistoryManager", "BIG_CARD_SECRET_DISPLAY_TIME");

		public static float BIG_CARD_POST_TRANSFORM_DISPLAY_TIME => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "HistoryManager", "BIG_CARD_POST_TRANSFORM_DISPLAY_TIME");

		public static float BIG_CARD_META_DATA_DISPLAY_TIME_SCALAR => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "HistoryManager", "BIG_CARD_META_DATA_DISPLAY_TIME_SCALAR");

		public static float SPACE_BETWEEN_TILES => MonoClass.smethod_6<float>(TritonHs.MainAssemblyPath, "", "HistoryManager", "SPACE_BETWEEN_TILES");

		public bool m_historyDisabled => method_2<bool>("m_historyDisabled");

		public List<HistoryCard> m_historyTiles => method_3<Class271<HistoryCard>>("m_historyTiles")?.method_25();

		public HistoryCard m_currentlyMousedOverTile => method_3<HistoryCard>("m_currentlyMousedOverTile");

		public List<TileEntry> m_queuedEntries => method_3<Class271<TileEntry>>("m_queuedEntries")?.method_25();

		public bool m_animatingVignette => method_2<bool>("m_animatingVignette");

		public bool m_animatingDesat => method_2<bool>("m_animatingDesat");

		public List<Vector3> m_bigCardPath => method_3<Class250<Vector3>>("m_bigCardPath")?.method_25();

		public BigCardEntry m_pendingBigCardEntry => method_3<BigCardEntry>("m_pendingBigCardEntry");

		public HistoryCard m_currentBigCard => method_3<HistoryCard>("m_currentBigCard");

		public bool m_showingBigCard => method_2<bool>("m_showingBigCard");

		public bool m_bigCardWaitingForSecret => method_2<bool>("m_bigCardWaitingForSecret");

		public BigCardTransformState m_bigCardTransformState => method_2<BigCardTransformState>("m_bigCardTransformState");

		public Spell m_bigCardTransformSpell => method_3<Spell>("m_bigCardTransformSpell");

		public HistoryManager(IntPtr address, string className)
			: base(address, className)
		{
		}

		public HistoryManager(IntPtr address)
			: this(address, "HistoryManager")
		{
		}

		public static HistoryManager Get()
		{
			return MonoClass.smethod_15<HistoryManager>(TritonHs.MainAssemblyPath, "", "HistoryManager", "Get", Array.Empty<object>());
		}

		public void Awake()
		{
			method_8("Awake");
		}

		public void OnDestroy()
		{
			method_8("OnDestroy");
		}

		public void Start()
		{
			method_8("Start");
		}

		public void DisableHistory()
		{
			method_8("DisableHistory");
		}

		public void EnableHistory()
		{
			method_8("EnableHistory");
		}

		public Entity CreatePreTransformedEntity(Entity entity)
		{
			return method_14<Entity>("CreatePreTransformedEntity", new object[1] { entity });
		}

		public void CreatePlayedTile(Entity playedEntity, Entity targetedEntity)
		{
			method_8("CreatePlayedTile", playedEntity, targetedEntity);
		}

		public void CreateTriggerTile(Entity triggeredEntity)
		{
			method_8("CreateTriggerTile", triggeredEntity);
		}

		public void CreateAttackTile(Entity attacker, Entity defender, PowerTaskList taskList)
		{
			method_8("CreateAttackTile", attacker, defender, taskList);
		}

		public void CreateFatigueTile()
		{
			method_8("CreateFatigueTile");
		}

		public void MarkCurrentHistoryEntryAsCompleted()
		{
			method_8("MarkCurrentHistoryEntryAsCompleted");
		}

		public bool HasHistoryEntry()
		{
			return method_11<bool>("HasHistoryEntry", Array.Empty<object>());
		}

		public void NotifyDamageChanged(Entity entity, int damage)
		{
			method_8("NotifyDamageChanged", entity, damage);
		}

		public void NotifyArmorChanged(Entity entity, int newArmor)
		{
			method_8("NotifyArmorChanged", entity, newArmor);
		}

		public void NotifyHealthChanged(Entity entity, int health)
		{
			method_8("NotifyHealthChanged", entity, health);
		}

		public void OverrideCurrentHistoryEntryWithMetaData()
		{
			method_8("OverrideCurrentHistoryEntryWithMetaData");
		}

		public HistoryInfo GetHistoryInfoForEntity(TileEntry entry, Entity entity)
		{
			return method_14<HistoryInfo>("GetHistoryInfoForEntity", new object[2] { entry, entity });
		}

		public bool NotifyEntityAffected(int entityId, bool allowDuplicates, bool fromMetaData, bool dontDuplicateUntilEnd)
		{
			return method_10<bool>("NotifyEntityAffected", new Class276.Enum20[4]
			{
				Class276.Enum20.I4,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean
			}, new object[4] { entityId, allowDuplicates, fromMetaData, dontDuplicateUntilEnd });
		}

		public bool NotifyEntityAffected(Entity entity, bool allowDuplicates, bool fromMetaData, bool dontDuplicateUntilEnd)
		{
			return method_10<bool>("NotifyEntityAffected", new Class276.Enum20[4]
			{
				Class276.Enum20.Class,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean,
				Class276.Enum20.Boolean
			}, new object[4] { entity, allowDuplicates, fromMetaData, dontDuplicateUntilEnd });
		}

		public void NotifyEntityDied(int entityId)
		{
			method_9("NotifyEntityDied", new Class276.Enum20[1] { Class276.Enum20.I4 }, entityId);
		}

		public void NotifyEntityDied(Entity entity)
		{
			method_9("NotifyEntityDied", new Class276.Enum20[1] { Class276.Enum20.Class }, entity);
		}

		public void NotifyOfInput(float zPosition)
		{
			method_8("NotifyOfInput", zPosition);
		}

		public void NotifyOfMouseOff()
		{
			method_8("NotifyOfMouseOff");
		}

		public void UpdateLayout()
		{
			method_8("UpdateLayout");
		}

		public int GetNumHistoryTiles()
		{
			return method_11<int>("GetNumHistoryTiles", Array.Empty<object>());
		}

		public int GetIndexForTile(HistoryCard tile)
		{
			return method_11<int>("GetIndexForTile", new object[1] { tile });
		}

		public void OnEntityRevealed()
		{
			method_8("OnEntityRevealed");
		}

		public void LoadNextHistoryEntry()
		{
			method_8("LoadNextHistoryEntry");
		}

		public void CreateTransformTile(HistoryInfo sourceInfo)
		{
			method_8("CreateTransformTile", sourceInfo);
		}

		public bool IsEntityTheLastCardTargeted(Entity entity)
		{
			return method_11<bool>("IsEntityTheLastCardTargeted", new object[1] { entity });
		}

		public bool IsEntityTheLastAttacker(Entity entity)
		{
			return method_11<bool>("IsEntityTheLastAttacker", new object[1] { entity });
		}

		public bool IsEntityTheLastCardPlayed(Entity entity)
		{
			return method_11<bool>("IsEntityTheLastCardPlayed", new object[1] { entity });
		}

		public bool IsEntityTheLastDefender(Entity entity)
		{
			return method_11<bool>("IsEntityTheLastDefender", new object[1] { entity });
		}

		public bool IsEntityTheAffectedCard(Entity entity, int index)
		{
			return method_11<bool>("IsEntityTheAffectedCard", new object[2] { entity, index });
		}

		public TileEntry GetCurrentHistoryEntry()
		{
			return method_14<TileEntry>("GetCurrentHistoryEntry", Array.Empty<object>());
		}

		public bool IsDeadInLaterHistoryEntry(Entity entity)
		{
			return method_11<bool>("IsDeadInLaterHistoryEntry", new object[1] { entity });
		}

		public void TileLoadedCallback(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("TileLoadedCallback", assetRef, go, callbackData);
		}

		public Texture DeterminePortraitTextureForTiles(Entity entity, CardDef cardDef)
		{
			return method_14<Texture>("DeterminePortraitTextureForTiles", new object[2] { entity, cardDef });
		}

		public void CheckForMouseOff()
		{
			method_8("CheckForMouseOff");
		}

		public void DestroyHistoryTilesThatFallOffTheEnd()
		{
			method_8("DestroyHistoryTilesThatFallOffTheEnd");
		}

		public void SetAsideTileAndTryToUpdate(HistoryCard tile)
		{
			method_8("SetAsideTileAndTryToUpdate", tile);
		}

		public Vector3 GetTopTilePosition()
		{
			return method_11<Vector3>("GetTopTilePosition", Array.Empty<object>());
		}

		public bool UserIsMousedOverAHistoryTile()
		{
			return method_11<bool>("UserIsMousedOverAHistoryTile", Array.Empty<object>());
		}

		public void FadeVignetteIn()
		{
			method_8("FadeVignetteIn");
		}

		public void FadeVignetteOut()
		{
			method_8("FadeVignetteOut");
		}

		public void AnimateVignetteIn()
		{
			method_8("AnimateVignetteIn");
		}

		public void AnimateVignetteOut()
		{
			method_8("AnimateVignetteOut");
		}

		public void OnUpdateVignetteVal(float val)
		{
			method_8("OnUpdateVignetteVal", val);
		}

		public void OnUpdateDesatVal(float val)
		{
			method_8("OnUpdateDesatVal", val);
		}

		public void OnVignetteInFinished()
		{
			method_8("OnVignetteInFinished");
		}

		public void OnDesatInFinished()
		{
			method_8("OnDesatInFinished");
		}

		public void OnVignetteOutFinished()
		{
			method_8("OnVignetteOutFinished");
		}

		public void OnDesatOutFinished()
		{
			method_8("OnDesatOutFinished");
		}

		public void OnFullScreenEffectOutFinished()
		{
			method_8("OnFullScreenEffectOutFinished");
		}

		public bool IsShowingBigCard()
		{
			return method_11<bool>("IsShowingBigCard", Array.Empty<object>());
		}

		public bool HasBigCard()
		{
			return method_11<bool>("HasBigCard", Array.Empty<object>());
		}

		public HistoryCard GetCurrentBigCard()
		{
			return method_14<HistoryCard>("GetCurrentBigCard", Array.Empty<object>());
		}

		public Entity GetPendingBigCardEntity()
		{
			return method_14<Entity>("GetPendingBigCardEntity", Array.Empty<object>());
		}

		public void NotifyOfSecretSpellFinished()
		{
			method_8("NotifyOfSecretSpellFinished");
		}

		public void HandleClickOnBigCard(HistoryCard card)
		{
			method_8("HandleClickOnBigCard", card);
		}

		public Vector3 GetBigCardPosition()
		{
			return method_11<Vector3>("GetBigCardPosition", Array.Empty<object>());
		}

		public void BigCardLoadedCallback(AssetReference assetRef, GameObject go, object callbackData)
		{
			method_8("BigCardLoadedCallback", assetRef, go, callbackData);
		}

		public void DestroyBigCard()
		{
			method_8("DestroyBigCard");
		}

		public void RunFinishedCallbackAndDestroyBigCard()
		{
			method_8("RunFinishedCallbackAndDestroyBigCard");
		}

		public void PlayBigCardCounteredEffects()
		{
			method_8("PlayBigCardCounteredEffects");
		}

		public void PlayBigCardTransformEffects()
		{
			method_8("PlayBigCardTransformEffects");
		}

		public void OnCurrentBigCardClicked()
		{
			method_8("OnCurrentBigCardClicked");
		}

		public void ForceNextBigCardTransformState()
		{
			method_8("ForceNextBigCardTransformState");
		}

		public void StopWaitingThenDestroyBigCard()
		{
			method_8("StopWaitingThenDestroyBigCard");
		}

		public void InterruptCurrentBigCard()
		{
			method_8("InterruptCurrentBigCard");
		}

		public void CutoffBigCardTransformEffects()
		{
			method_8("CutoffBigCardTransformEffects");
		}
	}
}
